package org.jradweb.core.web.servlet.view;

import org.springframework.beans.BeanUtils;
import org.springframework.util.ClassUtils;
import org.springframework.web.servlet.view.AbstractUrlBasedView;
import org.springframework.web.servlet.view.InternalResourceView;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;
import org.springframework.web.servlet.view.RedirectView;
import org.springframework.web.servlet.view.UrlBasedViewResolver;

public class JResourceViewResolver extends UrlBasedViewResolver {

	public static final String JS_URL_PREFIX = "js:";
	
	private Class jsViewClass=JsView.class;
	private String jsSuffix=".jssp";

	private static final boolean jstlPresent = ClassUtils.isPresent(
			"javax.servlet.jsp.jstl.core.Config",
			InternalResourceViewResolver.class.getClassLoader());

	private Boolean alwaysInclude;

	private Boolean exposeContextBeansAsAttributes;

	private String[] exposedContextBeanNames;

	/**
	 * Sets the default {@link #setViewClass view class} to
	 * {@link #requiredViewClass}: by default {@link InternalResourceView}, or
	 * {@link JstlView} if the JSTL API is present.
	 */
	public JResourceViewResolver() {
		Class viewClass = requiredViewClass();
		if (viewClass.equals(InternalResourceView.class) && jstlPresent) {
			viewClass = JstlView.class;
		}
		setViewClass(viewClass);
	}

	/**
	 * This resolver requires {@link InternalResourceView}.
	 */
	protected Class requiredViewClass() {
		return InternalResourceView.class;
	}

	/**
	 * Specify whether to always include the view rather than forward to it.
	 * <p>
	 * Default is "false". Switch this flag on to enforce the use of a Servlet
	 * include, even if a forward would be possible.
	 * 
	 * @see InternalResourceView#setAlwaysInclude
	 */
	public void setAlwaysInclude(boolean alwaysInclude) {
		this.alwaysInclude = Boolean.valueOf(alwaysInclude);
	}

	/**
	 * Set whether to make all Spring beans in the application context
	 * accessible as request attributes, through lazy checking once an attribute
	 * gets accessed.
	 * <p>
	 * This will make all such beans accessible in plain <code>${...}</code>
	 * expressions in a JSP 2.0 page, as well as in JSTL's <code>c:out</code>
	 * value expressions.
	 * <p>
	 * Default is "false".
	 * 
	 * @see InternalResourceView#setExposeContextBeansAsAttributes
	 */
	public void setExposeContextBeansAsAttributes(
			boolean exposeContextBeansAsAttributes) {
		this.exposeContextBeansAsAttributes = Boolean
				.valueOf(exposeContextBeansAsAttributes);
	}

	/**
	 * Specify the names of beans in the context which are supposed to be
	 * exposed. If this is non-null, only the specified beans are eligible for
	 * exposure as attributes.
	 * 
	 * @see InternalResourceView#setExposedContextBeanNames
	 */
	public void setExposedContextBeanNames(String[] exposedContextBeanNames) {
		this.exposedContextBeanNames = exposedContextBeanNames;
	}

	protected AbstractUrlBasedView buildView(String viewName) throws Exception {
		InternalResourceView view = (InternalResourceView) internalBuildView(viewName);
		if (this.alwaysInclude != null) {
			view.setAlwaysInclude(this.alwaysInclude.booleanValue());
		}
		if (this.exposeContextBeansAsAttributes != null) {
			view
					.setExposeContextBeansAsAttributes(this.exposeContextBeansAsAttributes
							.booleanValue());
		}
		if (this.exposedContextBeanNames != null) {
			view.setExposedContextBeanNames(this.exposedContextBeanNames);
		}
		view.setPreventDispatchLoop(true);
		return view;
	}

	private AbstractUrlBasedView internalBuildView(String viewName)
			throws Exception {
		String viewPath = null;
		AbstractUrlBasedView view = null;
		if (viewName.startsWith(JS_URL_PREFIX)) {
			viewPath = viewName.substring(JS_URL_PREFIX.length());
			view = (AbstractUrlBasedView) BeanUtils
					.instantiateClass(this.jsViewClass);
			view.setUrl(getPrefix() +  viewPath + this.getJsSuffix());
		} else {
			view = (AbstractUrlBasedView) BeanUtils
					.instantiateClass(getViewClass());
			view.setUrl(getPrefix() +viewName + getSuffix());
		}
		String contentType = getContentType();
		if (contentType != null) {
			view.setContentType(contentType);
		}
		view.setRequestContextAttribute(getRequestContextAttribute());
		view.setAttributesMap(getAttributesMap());
		return view;
	}

	public Class getJsViewClass() {
		return jsViewClass;
	}

	public void setJsViewClass(Class jsViewClass) {
		this.jsViewClass = jsViewClass;
	}

	public String getJsSuffix() {
		return jsSuffix;
	}

	public void setJsSuffix(String jsSuffix) {
		this.jsSuffix = jsSuffix;
	}
}
